1. Field of the Invention
The present invention is directed to computer systems. More particularly, it is directed to debugging applications running at resource-constrained computer systems.
2. Description of the Related Art
As processor technology has advanced in recent years, more and more applications have been developed for devices with small physical footprints and limited memory and power capacity, such as mobile phones, personal digital assistants, pagers and the like. Initially, many of the applications for such small devices were written in platform-specific programming languages; as a result, many of these applications were not easily portable and did not gain widespread acceptance. However, the demand for small resource-constrained devices continues to rise, for applications as varied as communication, environmental monitoring, cashless financial transactions, inventory management, national security, and the like.
More recently, versions of platform-independent virtual machine environments (e.g., Java™ virtual machines or JVMs) have been developed for some limited-memory platforms such as “smart cards” and battery-powered transducers, so that applications developed in widely supported high-level languages such as Java™ may be deployed to devices with limited memory. In order to be able to deploy these applications to devices with as little as a few hundred total kilobytes of memory, executable application code may be pre-processed prior to deployment, and converted into a simplified format (which may be termed a “suite” in the case of some applications written in Java™) that may be verified and loaded at the device. In addition, various other changes may be made to the application code before it is deployable to the device, such as the substitution of some byte codes by others, the removal of symbol information, and the like.
While the transformation of the application code may be required for deployment at limited-memory systems, both the transformation and the resource constraints on the devices themselves may lead to debugging and maintainability problems. For example, developers who write the application code may typically be familiar with using sophisticated interactive debugging tools to debug their code. Popular, standards-based debugging tools may be incompatible with the transformed versions of the applications; for example, some debuggers designed to interact with standard JVMs and standard Java™ classes may not be able to interact directly with suites at remote devices. As a result, applications developed using high-level languages may not be easily debuggable at the devices for which the applications are designed; e.g., while a developer may test and debug the application on a server or personal computer system at which the application was developed, only limited debugging may be possible on the resource-limited devices at which the applications are ultimately to be deployed. Furthermore, many remote debugging techniques may typically bundle a variety of debugging software modules into logically indivisible “all-or-nothing” packages; e.g., the debugger may not function unless the entire set of debugging modules is deployed at a targeted remote device to be debugged. Such all-or-nothing bundling techniques may not be appropriate for devices with very little memory and very limited power supplies.